Correct handling of name in firestore indexes #8862

joehan · 2025-07-17T18:24:35Z

Description

Fix index filtering to match the documented behavior. Builds off of #8860 - thank you for the help!
Fixes Fixes #7629, #8859

Scenarios Tested

Tested using the scenario @aalej set up in #8860 (comment) - it now works on repeated deployments!

Preserve __name__ fields with DESCENDING order while filtering out implicit ASCENDING ones to fix deployment conflicts. - Fixes duplicate index issues (#7629) - Fixes deployment conflicts (#8859) - Add comprehensive test coverage Fixes #7629, #8859

Refactored __name__ field filtering from listIndexes into static method FirestoreApi.processIndexes() to ensure tests verify production code rather than duplicating the implementation.

Simplified the filter expression in processIndexes() to a single boolean expression as suggested in PR feedback for better readability and conciseness.

… and it is the last field

gemini-code-assist

Summary of Changes

Hello @joehan, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request addresses and fixes an issue in Firestore index filtering where __name__ fields were incorrectly handled, leading to problems like duplicate index entries and deployment conflicts. The changes ensure that index listings accurately reflect the documented behavior, specifically by preserving __name__ fields with explicit DESCENDING order while filtering out implicit ASCENDING ones.

Highlights

Firestore Index Filtering Logic: Introduced a new static method FirestoreApi.processIndexes in src/firestore/api.ts to correctly filter __name__ fields in Firestore index listings. This method removes implicit __name__ fields (those with ASCENDING order matching the preceding field's order) while preserving explicit __name__ fields (e.g., those with DESCENDING order).
Index Listing Integration: The listIndexes method in src/firestore/api.ts now utilizes the FirestoreApi.processIndexes utility to ensure all returned index specifications adhere to the corrected filtering rules, aligning with documented behavior.
Comprehensive Testing: Added a new test suite IndexListingWithNameFields in src/firestore/indexes.spec.ts with multiple test cases to validate the processIndexes logic, covering various scenarios including different __name__ field orders and ensuring proper distinction between indexes.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Feature	Command	Description
Code Review	`/gemini review`	Performs a code review for the current pull request in its current state.
Pull Request Summary	`/gemini summary`	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in issue comments and review comments.
Help	`/gemini help`	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist is currently in preview and may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments to provide feedback.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

gemini-code-assist

Code Review

This pull request corrects the handling of implicit __name__ fields in Firestore indexes by filtering them out. The implementation has a critical bug that can cause a crash when processing an index with an empty fields array, and it also incorrectly handles indexes that only contain a __name__ field. Additionally, the new tests are missing coverage for this single-field __name__ index scenario.

src/firestore/api.ts

gemini-code-assist · 2025-07-17T18:26:36Z

src/firestore/indexes.spec.ts

+  it("should keep __name__ fields with DESCENDING order, when the default is ASCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.DESCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("__name__");
+    expect(result[0].fields[1].order).to.equal(API.Order.DESCENDING);
+  });
+
+  it("should keep __name__ fields with ASCENDING order, when the default is DESCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.DESCENDING },
+          { fieldPath: "__name__", order: API.Order.ASCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("__name__");
+    expect(result[0].fields[1].order).to.equal(API.Order.ASCENDING);
+  });
+
+  it("should distinguish between indexes that differ only by __name__ order", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.ASCENDING },
+        ],
+        state: API.State.READY,
+      },
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/def456",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.DESCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    // First index should have __name__ field filtered out
+    expect(result[0].fields).to.have.length(1);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+
+    // Second index should keep __name__ field with DESCENDING order
+    expect(result[1].fields).to.have.length(2);
+    expect(result[1].fields[0].fieldPath).to.equal("foo");
+    expect(result[1].fields[1].fieldPath).to.equal("__name__");
+    expect(result[1].fields[1].order).to.equal(API.Order.DESCENDING);
+
+    // The two processed indexes should be different (fixing the duplicate issue)
+    expect(JSON.stringify(result[0].fields)).to.not.equal(JSON.stringify(result[1].fields));
+  });
+
+  it("should handle indexes with no __name__ fields", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "bar", arrayConfig: API.ArrayConfig.CONTAINS },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("bar");
+  });
+});


The new tests cover composite indexes well, but they miss an important edge case: an index that only contains the __name__ field. Add test cases to verify the behavior for single-field __name__ indexes.

it("should filter out a single __name__ ASCENDING field", () => { const mockIndexes: API.Index[] = [ { name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123", queryScope: API.QueryScope.COLLECTION, fields: [ { fieldPath: "__name__", order: API.Order.ASCENDING }, ], state: API.State.READY, }, ]; const result = FirestoreApi.processIndexes(mockIndexes); expect(result[0].fields).to.have.length(0); }); it("should keep a single __name__ DESCENDING field", () => { const mockIndexes: API.Index[] = [ { name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123", queryScope: API.QueryScope.COLLECTION, fields: [ { fieldPath: "__name__", order: API.Order.DESCENDING }, ], state: API.State.READY, }, ]; const result = FirestoreApi.processIndexes(mockIndexes); expect(result[0].fields).to.have.length(1); expect(result[0].fields[0].fieldPath).to.equal("__name__"); expect(result[0].fields[0].order).to.equal(API.Order.DESCENDING); });

aalej

LGTM! Tested multiple deployments for each scenario

Deploy does not ask deletions when prod and local indexes match (OK)
Deploy correctly creates new indexes if they don't exist in prod (OK)
Deploying with __name__ explecitly set (OK)

Edit: Tested deploying to a new project(OK)

TorbenWetter and others added 5 commits July 17, 2025 14:40

refactor(firestore): extract index filtering logic to static method

5290d41

Refactored __name__ field filtering from listIndexes into static method FirestoreApi.processIndexes() to ensure tests verify production code rather than duplicating the implementation.

refactor(firestore): simplify processIndexes filter logic

fce1b90

Simplified the filter expression in processIndexes() to a single boolean expression as suggested in PR feedback for better readability and conciseness.

Update CHANGELOG.md

7a21aaa

Only filters __name__ when order matches order of last non name field…

bd6fadc

… and it is the last field

github-project-automation bot added this to [Cloud] Extensions + Functions Jul 17, 2025

joehan changed the title ~~Jh ind~~ Correct hadnling of __name__ in firestore indexes Jul 17, 2025

gemini-code-assist bot reviewed Jul 17, 2025

View reviewed changes

joehan changed the title ~~Correct hadnling of __name__ in firestore indexes~~ Correct handling of __name__ in firestore indexes Jul 17, 2025

gemini-code-assist bot reviewed Jul 17, 2025

View reviewed changes

joehan requested a review from aalej July 17, 2025 18:30

Super defensive

42fdcff

aalej approved these changes Jul 17, 2025

View reviewed changes

github-project-automation bot moved this to Approved [PR] in [Cloud] Extensions + Functions Jul 17, 2025

joehan enabled auto-merge (squash) July 17, 2025 20:35

joehan disabled auto-merge July 17, 2025 20:35

joehan merged commit 67ebf87 into master Jul 17, 2025
47 of 50 checks passed

joehan deleted the jh-ind branch July 17, 2025 20:35

github-project-automation bot moved this from Approved [PR] to Done in [Cloud] Extensions + Functions Jul 17, 2025

aalej mentioned this pull request Jul 22, 2025

firebase deploy --only firestore fails with 409 error on existing indexes in firebase-tools v14.11.0 and v14.12.1 #8859

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Correct handling of name in firestore indexes #8862

Correct handling of name in firestore indexes #8862

Uh oh!

joehan commented Jul 17, 2025

Uh oh!

gemini-code-assist bot left a comment

Uh oh!

gemini-code-assist bot left a comment

Uh oh!

Uh oh!

gemini-code-assist bot Jul 17, 2025

Uh oh!

aalej left a comment •

edited

Loading

Uh oh!

Uh oh!

Uh oh!

Correct handling of __name__ in firestore indexes #8862

Correct handling of __name__ in firestore indexes #8862

Uh oh!

Conversation

joehan commented Jul 17, 2025

Description

Scenarios Tested

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Summary of Changes

Highlights

Footnotes

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

Uh oh!

gemini-code-assist bot Jul 17, 2025

Choose a reason for hiding this comment

Uh oh!

aalej left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Correct handling of name in firestore indexes #8862

Correct handling of name in firestore indexes #8862

aalej left a comment •

edited

Loading